package com.forum.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.forum.bean.AdminUsers;
import com.forum.bean.UserProfiles;
import com.forum.bean.Users;
import com.forum.common.Result;
import com.forum.dto.*;
import com.forum.mapper.*;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.Date;

@Service
public class UsersService {

    @Autowired
    private UsersMapper usersMapper;

    @Autowired
    private UserProfileMapper userProfileMapper;

    @Autowired
    private ArticleLikeMapper articleLikeMapper;

    @Autowired
    private ArticlePaymentMapper articlePaymentMapper;
    @Autowired
    private AdminUsersMapper adminUsersMapper;



    public Result<String> editUserStatus(Integer id){
        Users result = usersMapper.selectById(id);
        int status =  result.getStatus();
        if(status == 1){
            result.setStatus(0);
        }else{
            result.setStatus(1);
        }
        usersMapper.updateById(result);
        return Result.ok("ok");
    }

    /**
     * 用户注册：录入 username, password, email, avatar, bio
     * 注：
     * - status 默认为 1，balance 默认为 0；
     * - 同时写入 users 表和 user_profiles
     */
    @Transactional
    public Result<Users> register(RegistrationRequest req) {
        try {
            // 查询email是否存在
            QueryWrapper<Users> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("email", req.getEmail());
            Users existingUser = usersMapper.selectOne(queryWrapper);
            if (existingUser != null) {
                return Result.fail("邮箱已被注册");
            }


            // 1. 新建用户记录，设置默认状态和余额
            Users user = new Users();
            user.setUsername(req.getUsername());
            user.setPassword(req.getPassword());
            user.setEmail(req.getEmail());
            user.setStatus(1);      // 默认待激活/正常状态为 1


            // 插入 users 表（自增长主键将自动赋值给 user.id）
            int rows = usersMapper.insert(user);
            if(rows != 1) {
                return Result.fail("注册失败，用户信息写入错误");
            }
            // 2. 新建用户扩展信息（user_profiles）
            UserProfiles profile = new UserProfiles();
            profile.setUserId(user.getId());
            profile.setAvatar(req.getAvatar());
            profile.setBio(req.getBio());
            profile.setBalance(new BigDecimal(0));   // 默认余额 0

            rows = userProfileMapper.insert(profile);
            if(rows != 1) {
                return Result.fail("注册失败，用户扩展信息写入错误");
            }
            // 成功返回注册的用户信息（或可以返回其它信息 DTO）
            return Result.ok(user);
        } catch(Exception e) {
            return Result.fail("注册异常：" + e.getMessage());
        }
    }


    @Transactional
    public Result<String> adminRegister(AdminLoginRequest req) {
        try {
            // 查询email是否存在
            QueryWrapper<AdminUsers> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("username", req.getUsername());
            AdminUsers existingUser = adminUsersMapper.selectOne(queryWrapper);
            if (existingUser != null) {
                return Result.fail("该用户名已被注册");
            }


            // 1. 新建用户记录，设置默认状态和余额
            AdminUsers user = new AdminUsers();
            user.setUsername(req.getUsername());
            user.setPassword(req.getPassword());



            // 插入 users 表（自增长主键将自动赋值给 user.id）
            int rows = adminUsersMapper.insert(user);
            if(rows != 1) {
                return Result.fail("注册失败，用户信息写入错误");
            }
            // 成功返回注册的用户信息（或可以返回其它信息 DTO）
            return Result.ok("注册成功");
        } catch(Exception e) {
            return Result.fail("注册异常：" + e.getMessage());
        }
    }

    /**
     * 充值接口：入参 rechargeRequest 包含用户ID 和充值金额
     * 逻辑：
     * 1. 校验充值金额必须大于0
     * 2. 查询用户是否存在
     * 3. 累加充值金额后更新用户余额
     */
    @Transactional
    public Result<UserProfiles> recharge(RechargeRequest request) {
        try {
            if (request.getAmount() == null || request.getAmount().compareTo(BigDecimal.ZERO) <= 0) {
                return Result.fail("充值金额必须大于0");
            }
            QueryWrapper<UserProfiles> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("user_id", request.getUserId());
            UserProfiles userProfile = userProfileMapper.selectOne(queryWrapper);
            if (userProfile == null) {
                return Result.fail("用户不存在");
            }
            BigDecimal currentBalance = userProfile.getBalance();
            if (currentBalance == null) {
                currentBalance = new BigDecimal(0);
            }
            userProfile.setBalance(currentBalance.add(request.getAmount()));

            int rows = userProfileMapper.updateById(userProfile);
            if (rows != 1) {
                return Result.fail("充值失败");
            }
            return Result.ok(userProfile);
        } catch(Exception e) {
            return Result.fail("充值异常：" + e.getMessage());
        }
    }

    /**
     * 修改密码接口
     * 1. 根据 userId 查询用户
     * 2. 比较 oldPassword 与存储的密码是否一致
     * 3. 若一致则更新为 newPassword，否则返回错误
     */
    @Transactional
    public Result<String> changePassword(ChangePasswordRequest req) {
        try {
            // 参数校验
            if (req.getUserId() == null || req.getOldPassword() == null || req.getNewPassword() == null) {
                return Result.fail("参数不完整");
            }
            // 查询用户
            Users user = usersMapper.selectById(req.getUserId());
            if (user == null) {
                return Result.fail("用户不存在");
            }
            if (!user.getPassword().equals(req.getOldPassword())) {
                return Result.fail("旧密码错误");
            }
            // 更新密码，设置为新密码
            user.setPassword(req.getNewPassword());
            int rows = usersMapper.updateById(user);
            if (rows != 1) {
                return Result.fail("修改密码失败");
            }
            return Result.ok("修改密码成功");
        } catch (Exception e) {
            return Result.fail("修改密码异常：" + e.getMessage());
        }
    }


    /**
     * 修改个人信息接口
     * 1. 根据 userId 更新 users 表中的 username 和 email
     * 2. 根据 user_id 查找 user_profiles 表记录，若存在则更新 avatar 和 bio，否则创建一条新记录
     */
    @Transactional
    public Result<String> updateProfile(UpdateProfileRequest request) {
        try {
            Integer userId = request.getUserId();
            if (userId == null) {
                return Result.fail("用户ID不能为空");
            }

            // 更新 users 表
            Users user = usersMapper.selectById(userId);
            if (user == null) {
                return Result.fail("用户不存在");
            }
            user.setUsername(request.getUsername());
            int rows = usersMapper.updateById(user);
            if (rows != 1) {
                return Result.fail("更新用户基本信息失败");
            }

            // 更新 user_profiles 表：按 user_id 查找记录
            QueryWrapper<UserProfiles> wrapper = new QueryWrapper<>();
            wrapper.eq("user_id", userId);
            UserProfiles profile = userProfileMapper.selectOne(wrapper);
            if (profile == null) {
                // 无记录则创建
                profile = new UserProfiles();
                profile.setUserId(userId);
                profile.setAvatar(request.getAvatar());
                profile.setBio(request.getBio());
                rows = userProfileMapper.insert(profile);
                if (rows != 1) {
                    return Result.fail("创建用户扩展信息失败");
                }
            } else {
                // 有记录则更新
                profile.setAvatar(request.getAvatar());
                profile.setBio(request.getBio());
                rows = userProfileMapper.updateById(profile);
                if (rows != 1) {
                    return Result.fail("更新用户扩展信息失败");
                }
            }
            return Result.ok("个人信息更新成功");
        } catch (Exception e) {
            return Result.fail("更新个人信息异常：" + e.getMessage());
        }
    }


    /**
     * 查询用户详细信息接口
     * @param userId 要查询的用户ID
     * @param currentUserId 当前登录用户ID
     * @return 包含用户详细信息的 Result 对象
     */
    public Result<UserDetailDto> getUserDetail(Integer userId, Integer currentUserId) {
        try {
            UserDetailDto detail = usersMapper.selectUserDetail(userId, currentUserId);
            if (detail == null) {
                return Result.fail("用户不存在");
            }
            return Result.ok(detail);
        } catch (Exception e) {
            return Result.fail("查询用户详细信息异常：" + e.getMessage());
        }
    }


    // JWT 密钥（建议放在配置文件或环境变量中）
    private final String JWT_SECRET = "your_secret_key";
    // JWT 有效期，这里设置为一天（毫秒）
    private final long JWT_EXPIRATION = 86400000L; // 24 * 60 * 60 * 1000


    public Result<String> login(AdminLoginRequest request){
        QueryWrapper<AdminUsers> query = new QueryWrapper<>();
        query.eq("username", request.getUsername());
        AdminUsers user = adminUsersMapper.selectOne(query);
        if(user == null){
            return Result.fail("用户不存在");
        }

        if (!user.getPassword().equals(request.getPassword())) {
            return Result.fail("密码错误");
        }

        return Result.ok("登录成功");

    }



    public Result<LoginResponse> login(LoginRequest request) {
        // 根据邮箱查询用户
        QueryWrapper<Users> query = new QueryWrapper<>();
        query.eq("email", request.getEmail());
        Users user = usersMapper.selectOne(query);
        if (user == null) {
            return Result.fail("用户不存在");
        }
        if(user.getStatus() == 0){
            return Result.fail("用户已被封禁");
        }
        // 简单明文密码比较（实际请使用密码加密校验）
        if (!user.getPassword().equals(request.getPassword())) {
            return Result.fail("密码错误");
        }

        // 生成 JWT Token
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + JWT_EXPIRATION);

        String token = Jwts.builder()
                .setSubject(user.getId().toString())
                .claim("username", user.getUsername())
                .claim("email", user.getEmail())
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, JWT_SECRET)
                .compact();

        LoginResponse response = new LoginResponse(token);
        response.setUserProfiles(usersMapper.selectUserDetail(user.getId(),user.getId()));
        return Result.ok(response);
    }



    /**
     * 分页获取点赞记录列表
     * @param userId 点赞用户ID
     * @param pageNum 当前页码
     * @param pageSize 每页条数
     * @return 点赞记录的分页查询结果
     */
    public Result<IPage<LikeListDto>> getLikeList(Integer userId, int pageNum, int pageSize) {
        try {
            Page<LikeListDto> page = new Page<>(pageNum, pageSize);
            IPage<LikeListDto> likePage = articleLikeMapper.selectLikeList(page, userId);
            return Result.ok(likePage);
        } catch (Exception e) {
            return Result.fail("查询点赞列表异常：" + e.getMessage());
        }
    }



    /**
     * 分页获取付费记录列表
     * @param userId 付费用户ID
     * @param pageNum 当前页码
     * @param pageSize 每页条数
     * @return 付费记录的分页查询结果
     */
    public Result<IPage<PaymentListDto>> getPaymentList(Integer userId, int pageNum, int pageSize) {
        try {
            Page<PaymentListDto> page = new Page<>(pageNum, pageSize);
            IPage<PaymentListDto> likePage = articlePaymentMapper.selectPaymentList(page, userId);
            return Result.ok(likePage);
        } catch (Exception e) {
            return Result.fail("查询点赞列表异常：" + e.getMessage());
        }
    }



    /**
     * 分页查询用户列表，包括基本信息和扩展信息
     *
     * @param pageNum 当前页码
     * @param pageSize 每页记录数
     * @return 分页查询结果封装在 Result 中
     */
    public Result<IPage<UserListDto>> getUserList(int pageNum, int pageSize,String searchKey) {
        try {
            Page<UserListDto> page = new Page<>(pageNum, pageSize);
            IPage<UserListDto> userPage = usersMapper.selectUserList(page,searchKey);
            return Result.ok(userPage);
        } catch (Exception e) {
            return Result.fail("查询用户列表异常：" + e.getMessage());
        }
    }


    /**
     * 分页查询管理员列表
     * @param pageNum 当前页码
     * @param pageSize 每页记录数
     * @return 分页查询结果，包含管理员基本信息列表
     */
    public Result<IPage<AdminUserListDto>> getAdminList(int pageNum, int pageSize) {
        try {
            Page<AdminUserListDto> page = new Page<>(pageNum, pageSize);
            IPage<AdminUserListDto> resultPage = adminUsersMapper.selectAdminList(page);
            return Result.ok(resultPage);
        } catch (Exception e) {
            return Result.fail("查询管理员列表异常：" + e.getMessage());
        }
    }


    /**
     * 新增管理员功能
     * @param req 请求对象，只包含 username 和 password
     * @return 返回操作结果
     */
    @Transactional
    public Result<String> createAdmin(AdminCreateRequest req) {
        if (req.getUsername() == null || req.getPassword() == null || req.getUsername().trim().isEmpty() || req.getPassword().trim().isEmpty()) {
            return Result.fail("参数不完整");
        }
        // 构建 AdminUsers 对象，不涉及 email 字段
        AdminUsers admin = new AdminUsers();
        admin.setUsername(req.getUsername());
        admin.setPassword(req.getPassword());
        // 邮箱不设置，保持默认值

        int rows = adminUsersMapper.insert(admin);
        if (rows == 1) {
            return Result.ok("新增管理员成功");
        } else {
            return Result.fail("新增管理员失败");
        }
    }


//  delete

    /**
     * 删除管理员功能
     * @return 返回操作结果
     */

    @Transactional
    public Result<String> deleteAdmin(Integer adminId) {
        if (adminId == null) {
            return Result.fail("管理员ID不能为空");
        }
        // 删除管理员记录
        int rows = adminUsersMapper.deleteById(adminId);
        if (rows == 1) {
            return Result.ok("删除管理员成功");
        } else {
            return Result.fail("删除管理员失败");
        }
    }



    public Result<AdminLoginResponse> adminLogin(AdminLoginRequest request) {
        QueryWrapper<AdminUsers> query = new QueryWrapper<>();
        query.eq("username", request.getUsername());
        AdminUsers adminUser = adminUsersMapper.selectOne(query);
        if (adminUser == null) {
            return Result.fail("管理员不存在");
        }
        // 注意：实际生产环境下请使用密码加密和校验，此处为简单示例直接比较明文密码
        if (!adminUser.getPassword().equals(request.getPassword())) {
            return Result.fail("密码错误");
        }
        // 生成 JWT Token
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + JWT_EXPIRATION);

        String token = Jwts.builder()
                .setSubject(adminUser.getId().toString())
                .claim("username", adminUser.getUsername())
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, JWT_SECRET)
                .compact();

        AdminLoginResponse response = new AdminLoginResponse(token);
        response.setUsername(adminUser.getUsername());
        return Result.ok(response);
    }

}
